﻿using Neural;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
using System.Collections;

namespace NNTest
{
    
    
    /// <summary>
    ///This is a test class for NetworkTest and is intended
    ///to contain all NetworkTest Unit Tests
    ///</summary>
    [TestClass()]
    public class NetworkTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Additional test attributes
        // 
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///A test for ValidateInputs
        ///</summary>
        [TestMethod()]
        public void ValidateInputsTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            target.ValidateInputs = expected;
            actual = target.ValidateInputs;
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for NueronNames
        ///</summary>
        [TestMethod()]
        public void NueronNamesTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            ArrayList actual;
            actual = target.NueronNames;
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for Item
        ///</summary>
        [TestMethod()]
        public void ItemTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            string name = string.Empty; // TODO: Initialize to an appropriate value
            Neuron actual;
            actual = target[name];
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for ActivationFactory
        ///</summary>
        [TestMethod()]
        public void ActivationFactoryTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            ActivationFactory expected = null; // TODO: Initialize to an appropriate value
            ActivationFactory actual;
            target.ActivationFactory = expected;
            actual = target.ActivationFactory;
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for UpdateAdjustments
        ///</summary>
        [TestMethod()]
        public void UpdateAdjustmentsTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            target.UpdateAdjustments();
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for SetFeedback
        ///</summary>
        [TestMethod()]
        public void SetFeedbackTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            Dictionary<string, double> actual = null; // TODO: Initialize to an appropriate value
            Dictionary<string, double> expected = null; // TODO: Initialize to an appropriate value
            target.SetFeedback(actual, expected);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for Process
        ///</summary>
        [TestMethod()]
        public void ProcessTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            Dictionary<string, double> inputs = null; // TODO: Initialize to an appropriate value
            Dictionary<string, double> expected = null; // TODO: Initialize to an appropriate value
            Dictionary<string, double> actual;
            actual = target.Process(inputs);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for getTrainer
        ///</summary>
        [TestMethod()]
        public void getTrainerTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            string neuronId = string.Empty; // TODO: Initialize to an appropriate value
            NeuronTraining expected = null; // TODO: Initialize to an appropriate value
            NeuronTraining actual;
            actual = target.getTrainer(neuronId);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for EndTraining
        ///</summary>
        [TestMethod()]
        public void EndTrainingTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            target.EndTraining();
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for ConnectToBias
        ///</summary>
        [TestMethod()]
        [DeploymentItem("Neural.NET.dll")]
        public void ConnectToBiasTest()
        {
            Network_Accessor target = new Network_Accessor(); // TODO: Initialize to an appropriate value
            Neuron neuron = null; // TODO: Initialize to an appropriate value
            target.ConnectToBias(neuron);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for Connect
        ///</summary>
        [TestMethod()]
        public void ConnectTest1()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            Neuron baseNeuron = null; // TODO: Initialize to an appropriate value
            Neuron dendrite = null; // TODO: Initialize to an appropriate value
            target.Connect(baseNeuron, dendrite);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for Connect
        ///</summary>
        [TestMethod()]
        public void ConnectTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            string baseNeuron = string.Empty; // TODO: Initialize to an appropriate value
            string dendrite = string.Empty; // TODO: Initialize to an appropriate value
            target.Connect(baseNeuron, dendrite);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for BeginTraining
        ///</summary>
        [TestMethod()]
        public void BeginTrainingTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            Trainer trainer = null; // TODO: Initialize to an appropriate value
            target.BeginTraining(trainer);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for AdjustWeights
        ///</summary>
        [TestMethod()]
        public void AdjustWeightsTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            target.AdjustWeights();
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for AddOutputNeuron
        ///</summary>
        [TestMethod()]
        public void AddOutputNeuronTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            Neuron neuron = new Neuron("Fred"); // TODO: Initialize to an appropriate value
            target.AddOutputNeuron(neuron);
            Assert.IsTrue(target.NueronNames.Contains("Fred"));
        }

        /// <summary>
        ///A test for AddNeuron
        ///</summary>
        [TestMethod()]
        [DeploymentItem("Neural.NET.dll")]
        public void AddNeuronTest()
        {
            Network_Accessor target = new Network_Accessor(); // TODO: Initialize to an appropriate value
            Neuron neuron = null; // TODO: Initialize to an appropriate value
            target.AddNeuron(neuron);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for AddInternalNeuron
        ///</summary>
        [TestMethod()]
        public void AddInternalNeuronTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            Neuron neuron = null; // TODO: Initialize to an appropriate value
            target.AddInternalNeuron(neuron);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for AddInputNeuron
        ///</summary>
        [TestMethod()]
        public void AddInputNeuronTest()
        {
            Network target = new Network(); // TODO: Initialize to an appropriate value
            Neuron neuron = null; // TODO: Initialize to an appropriate value
            target.AddInputNeuron(neuron);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for Network Constructor
        ///</summary>
        [TestMethod()]
        public void NetworkConstructorTest()
        {
            Network target = new Network();
            Assert.Inconclusive("TODO: Implement code to verify target");
        }
    }
}
